---
layout: "default"
title: "Operator: +"
description: "Swift documentation for the '+' operator."
root: "/v4.2"
---

<code class="language-swift"> operator + {
    associativity left
    precedence 
}</code>

<h3>Declarations</h3>

<div class="declaration" id="func-pls_-double-rhs_-double">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-pls_-double-rhs_-double">func +(<wbr>_:<wbr> Double, rhs: Double)</a>
        
<div class="comment collapse" id="comment-func-pls_-double-rhs_-double"><div class="p">
    <p>Adds two values and produces their sum, rounded to a
representable value.</p>

<p>The addition operator (<code>+</code>) calculates the sum of its two arguments. For
example:</p>

<pre><code class="language-swift">let x = 1.5
let y = x + 2.25
// y == 3.75</code></pre>

<p>The <code>+</code> operator implements the addition operation defined by the
<a href="http://ieeexplore.ieee.org/servlet/opac?punumber=4610933">IEEE 754 specification</a>.</p>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> The first value to add.
  <strong>rhs:</strong> The second value to add.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func +(lhs: Double, rhs: Double) -&gt; Double</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-pls_-float-rhs_-float">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-pls_-float-rhs_-float">func +(<wbr>_:<wbr> Float, rhs: Float)</a>
        
<div class="comment collapse" id="comment-func-pls_-float-rhs_-float"><div class="p">
    <p>Adds two values and produces their sum, rounded to a
representable value.</p>

<p>The addition operator (<code>+</code>) calculates the sum of its two arguments. For
example:</p>

<pre><code class="language-swift">let x = 1.5
let y = x + 2.25
// y == 3.75</code></pre>

<p>The <code>+</code> operator implements the addition operation defined by the
<a href="http://ieeexplore.ieee.org/servlet/opac?punumber=4610933">IEEE 754 specification</a>.</p>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> The first value to add.
  <strong>rhs:</strong> The second value to add.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func +(lhs: Float, rhs: Float) -&gt; Float</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-pls_-float80-rhs_-float80">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-pls_-float80-rhs_-float80">func +(<wbr>_:<wbr> Float80, rhs: Float80)</a>
        
<div class="comment collapse" id="comment-func-pls_-float80-rhs_-float80"><div class="p">
    <p>Adds two values and produces their sum, rounded to a
representable value.</p>

<p>The addition operator (<code>+</code>) calculates the sum of its two arguments. For
example:</p>

<pre><code class="language-swift">let x = 1.5
let y = x + 2.25
// y == 3.75</code></pre>

<p>The <code>+</code> operator implements the addition operation defined by the
<a href="http://ieeexplore.ieee.org/servlet/opac?punumber=4610933">IEEE 754 specification</a>.</p>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> The first value to add.
  <strong>rhs:</strong> The second value to add.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func +(lhs: Float80, rhs: Float80) -&gt; Float80</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-pls_-int-rhs_-int">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-pls_-int-rhs_-int">func +(<wbr>_:<wbr> Int, rhs: Int)</a>
        
<div class="comment collapse" id="comment-func-pls_-int-rhs_-int"><div class="p">
    <p>Adds two values and produces their sum.</p>

<p>The addition operator (<code>+</code>) calculates the sum of its two arguments. For
example:</p>

<pre><code class="language-swift">1 + 2                   // 3
-10 + 15                // 5
-15 + -5                // -20
21.5 + 3.25             // 24.75</code></pre>

<p>You cannot use <code>+</code> with arguments of different types. To add values of
different types, convert one of the values to the other value&#39;s type.</p>

<pre><code class="language-swift">let x: Int8 = 21
let y: Int = 1000000
Int(x) + y              // 1000021</code></pre>

<p>The sum of the two arguments must be representable in the arguments&#39;
type. In the following example, the result of <code>21 + 120</code> is greater than
the maximum representable <code>Int8</code> value:</p>

<pre><code class="language-swift">x + 120                 // Overflow error</code></pre>

<p><strong>Note:</strong> Overflow checking is not performed in <code>-Ounchecked</code> builds.</p>

<p>If you want to opt out of overflow checking and ignore any overflow, use
the overflow addition operator (<code>&amp;+</code>).</p>

<pre><code class="language-swift">x &amp;+ 120                // -115</code></pre>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> The first value to add.
  <strong>rhs:</strong> The second value to add.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func +(lhs: Int, rhs: Int) -&gt; Int</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-pls_-int8-rhs_-int8">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-pls_-int8-rhs_-int8">func +(<wbr>_:<wbr> Int8, rhs: Int8)</a>
        
<div class="comment collapse" id="comment-func-pls_-int8-rhs_-int8"><div class="p">
    <p>Adds two values and produces their sum.</p>

<p>The addition operator (<code>+</code>) calculates the sum of its two arguments. For
example:</p>

<pre><code class="language-swift">1 + 2                   // 3
-10 + 15                // 5
-15 + -5                // -20
21.5 + 3.25             // 24.75</code></pre>

<p>You cannot use <code>+</code> with arguments of different types. To add values of
different types, convert one of the values to the other value&#39;s type.</p>

<pre><code class="language-swift">let x: Int8 = 21
let y: Int = 1000000
Int(x) + y              // 1000021</code></pre>

<p>The sum of the two arguments must be representable in the arguments&#39;
type. In the following example, the result of <code>21 + 120</code> is greater than
the maximum representable <code>Int8</code> value:</p>

<pre><code class="language-swift">x + 120                 // Overflow error</code></pre>

<p><strong>Note:</strong> Overflow checking is not performed in <code>-Ounchecked</code> builds.</p>

<p>If you want to opt out of overflow checking and ignore any overflow, use
the overflow addition operator (<code>&amp;+</code>).</p>

<pre><code class="language-swift">x &amp;+ 120                // -115</code></pre>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> The first value to add.
  <strong>rhs:</strong> The second value to add.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func +(lhs: Int8, rhs: Int8) -&gt; Int8</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-pls_-int16-rhs_-int16">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-pls_-int16-rhs_-int16">func +(<wbr>_:<wbr> Int16, rhs: Int16)</a>
        
<div class="comment collapse" id="comment-func-pls_-int16-rhs_-int16"><div class="p">
    <p>Adds two values and produces their sum.</p>

<p>The addition operator (<code>+</code>) calculates the sum of its two arguments. For
example:</p>

<pre><code class="language-swift">1 + 2                   // 3
-10 + 15                // 5
-15 + -5                // -20
21.5 + 3.25             // 24.75</code></pre>

<p>You cannot use <code>+</code> with arguments of different types. To add values of
different types, convert one of the values to the other value&#39;s type.</p>

<pre><code class="language-swift">let x: Int8 = 21
let y: Int = 1000000
Int(x) + y              // 1000021</code></pre>

<p>The sum of the two arguments must be representable in the arguments&#39;
type. In the following example, the result of <code>21 + 120</code> is greater than
the maximum representable <code>Int8</code> value:</p>

<pre><code class="language-swift">x + 120                 // Overflow error</code></pre>

<p><strong>Note:</strong> Overflow checking is not performed in <code>-Ounchecked</code> builds.</p>

<p>If you want to opt out of overflow checking and ignore any overflow, use
the overflow addition operator (<code>&amp;+</code>).</p>

<pre><code class="language-swift">x &amp;+ 120                // -115</code></pre>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> The first value to add.
  <strong>rhs:</strong> The second value to add.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func +(lhs: Int16, rhs: Int16) -&gt; Int16</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-pls_-int32-rhs_-int32">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-pls_-int32-rhs_-int32">func +(<wbr>_:<wbr> Int32, rhs: Int32)</a>
        
<div class="comment collapse" id="comment-func-pls_-int32-rhs_-int32"><div class="p">
    <p>Adds two values and produces their sum.</p>

<p>The addition operator (<code>+</code>) calculates the sum of its two arguments. For
example:</p>

<pre><code class="language-swift">1 + 2                   // 3
-10 + 15                // 5
-15 + -5                // -20
21.5 + 3.25             // 24.75</code></pre>

<p>You cannot use <code>+</code> with arguments of different types. To add values of
different types, convert one of the values to the other value&#39;s type.</p>

<pre><code class="language-swift">let x: Int8 = 21
let y: Int = 1000000
Int(x) + y              // 1000021</code></pre>

<p>The sum of the two arguments must be representable in the arguments&#39;
type. In the following example, the result of <code>21 + 120</code> is greater than
the maximum representable <code>Int8</code> value:</p>

<pre><code class="language-swift">x + 120                 // Overflow error</code></pre>

<p><strong>Note:</strong> Overflow checking is not performed in <code>-Ounchecked</code> builds.</p>

<p>If you want to opt out of overflow checking and ignore any overflow, use
the overflow addition operator (<code>&amp;+</code>).</p>

<pre><code class="language-swift">x &amp;+ 120                // -115</code></pre>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> The first value to add.
  <strong>rhs:</strong> The second value to add.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func +(lhs: Int32, rhs: Int32) -&gt; Int32</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-pls_-int64-rhs_-int64">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-pls_-int64-rhs_-int64">func +(<wbr>_:<wbr> Int64, rhs: Int64)</a>
        
<div class="comment collapse" id="comment-func-pls_-int64-rhs_-int64"><div class="p">
    <p>Adds two values and produces their sum.</p>

<p>The addition operator (<code>+</code>) calculates the sum of its two arguments. For
example:</p>

<pre><code class="language-swift">1 + 2                   // 3
-10 + 15                // 5
-15 + -5                // -20
21.5 + 3.25             // 24.75</code></pre>

<p>You cannot use <code>+</code> with arguments of different types. To add values of
different types, convert one of the values to the other value&#39;s type.</p>

<pre><code class="language-swift">let x: Int8 = 21
let y: Int = 1000000
Int(x) + y              // 1000021</code></pre>

<p>The sum of the two arguments must be representable in the arguments&#39;
type. In the following example, the result of <code>21 + 120</code> is greater than
the maximum representable <code>Int8</code> value:</p>

<pre><code class="language-swift">x + 120                 // Overflow error</code></pre>

<p><strong>Note:</strong> Overflow checking is not performed in <code>-Ounchecked</code> builds.</p>

<p>If you want to opt out of overflow checking and ignore any overflow, use
the overflow addition operator (<code>&amp;+</code>).</p>

<pre><code class="language-swift">x &amp;+ 120                // -115</code></pre>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> The first value to add.
  <strong>rhs:</strong> The second value to add.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func +(lhs: Int64, rhs: Int64) -&gt; Int64</code>
    
    
</div></div>
</div>
<div class="declaration inherited" id="func-pls_-self-rhs_-self-stride">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-pls_-self-rhs_-self-stride">func +(<wbr>_:<wbr> Self, rhs: Self.Stride)</a>
        
<div class="comment collapse" id="comment-func-pls_-self-rhs_-self-stride"><div class="p">
    <p>Adds two values and produces their sum.</p>

<p>The addition operator (<code>+</code>) calculates the sum of its two arguments. For
example:</p>

<pre><code class="language-swift">1 + 2                   // 3
-10 + 15                // 5
-15 + -5                // -20
21.5 + 3.25             // 24.75</code></pre>

<p>You cannot use <code>+</code> with arguments of different types. To add values of
different types, convert one of the values to the other value&#39;s type.</p>

<pre><code class="language-swift">let x: Int8 = 21
let y: Int = 1000000
Int(x) + y              // 1000021</code></pre>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> The first value to add.
  <strong>rhs:</strong> The second value to add.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func +(lhs: Self, rhs: Self.Stride) -&gt; Self</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/FixedWidthInteger/"><code>FixedWidthInteger</code></a>    
</div></div>
</div>
<div class="declaration inherited" id="func-pls_-self-rhs_-self-stride">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-pls_-self-rhs_-self-stride">func +(<wbr>_:<wbr> Self, rhs: Self.Stride)</a>
        
<div class="comment collapse" id="comment-func-pls_-self-rhs_-self-stride"><div class="p">
    <p>Adds two values and produces their sum.</p>

<p>The addition operator (<code>+</code>) calculates the sum of its two arguments. For
example:</p>

<pre><code class="language-swift">1 + 2                   // 3
-10 + 15                // 5
-15 + -5                // -20
21.5 + 3.25             // 24.75</code></pre>

<p>You cannot use <code>+</code> with arguments of different types. To add values of
different types, convert one of the values to the other value&#39;s type.</p>

<pre><code class="language-swift">let x: Int8 = 21
let y: Int = 1000000
Int(x) + y              // 1000021</code></pre>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> The first value to add.
  <strong>rhs:</strong> The second value to add.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func +(lhs: Self, rhs: Self.Stride) -&gt; Self</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/FixedWidthInteger/"><code>FixedWidthInteger</code></a>    
</div></div>
</div>
<div class="declaration inherited" id="func-pls_-self-rhs_-self-stride">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-pls_-self-rhs_-self-stride">func +(<wbr>_:<wbr> Self, rhs: Self.Stride)</a>
        
<div class="comment collapse" id="comment-func-pls_-self-rhs_-self-stride"><div class="p">
    <p>Adds two values and produces their sum.</p>

<p>The addition operator (<code>+</code>) calculates the sum of its two arguments. For
example:</p>

<pre><code class="language-swift">1 + 2                   // 3
-10 + 15                // 5
-15 + -5                // -20
21.5 + 3.25             // 24.75</code></pre>

<p>You cannot use <code>+</code> with arguments of different types. To add values of
different types, convert one of the values to the other value&#39;s type.</p>

<pre><code class="language-swift">let x: Int8 = 21
let y: Int = 1000000
Int(x) + y              // 1000021</code></pre>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> The first value to add.
  <strong>rhs:</strong> The second value to add.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func +(lhs: Self, rhs: Self.Stride) -&gt; Self</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/FixedWidthInteger/"><code>FixedWidthInteger</code></a>    
</div></div>
</div>
<div class="declaration inherited" id="func-pls_-self-rhs_-self-stride">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-pls_-self-rhs_-self-stride">func +(<wbr>_:<wbr> Self, rhs: Self.Stride)</a>
        
<div class="comment collapse" id="comment-func-pls_-self-rhs_-self-stride"><div class="p">
    <p>Adds two values and produces their sum, rounded to a
representable value.</p>

<p>The addition operator (<code>+</code>) calculates the sum of its two arguments. For
example:</p>

<pre><code class="language-swift">let x = 1.5
let y = x + 2.25
// y == 3.75</code></pre>

<p>The <code>+</code> operator implements the addition operation defined by the
<a href="http://ieeexplore.ieee.org/servlet/opac?punumber=4610933">IEEE 754 specification</a>.</p>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> The first value to add.
  <strong>rhs:</strong> The second value to add.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func +(lhs: Self, rhs: Self.Stride) -&gt; Self</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/BinaryFloatingPoint/"><code>BinaryFloatingPoint</code></a>,    <a href="../../protocol/Strideable/"><code>Strideable</code></a>    
</div></div>
</div>
<div class="declaration inherited" id="func-pls_-self-rhs_-self-stride">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-pls_-self-rhs_-self-stride">func +(<wbr>_:<wbr> Self, rhs: Self.Stride)</a>
        
<div class="comment collapse" id="comment-func-pls_-self-rhs_-self-stride"><div class="p">
    <p>Adds two values and produces their sum.</p>

<p>The addition operator (<code>+</code>) calculates the sum of its two arguments. For
example:</p>

<pre><code class="language-swift">1 + 2                   // 3
-10 + 15                // 5
-15 + -5                // -20
21.5 + 3.25             // 24.75</code></pre>

<p>You cannot use <code>+</code> with arguments of different types. To add values of
different types, convert one of the values to the other value&#39;s type.</p>

<pre><code class="language-swift">let x: Int8 = 21
let y: Int = 1000000
Int(x) + y              // 1000021</code></pre>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> The first value to add.
  <strong>rhs:</strong> The second value to add.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func +(lhs: Self, rhs: Self.Stride) -&gt; Self</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/FixedWidthInteger/"><code>FixedWidthInteger</code></a>    
</div></div>
</div>
<div class="declaration inherited" id="func-pls_-self-rhs_-self-stride">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-pls_-self-rhs_-self-stride">func +(<wbr>_:<wbr> Self, rhs: Self.Stride)</a>
        
<div class="comment collapse" id="comment-func-pls_-self-rhs_-self-stride"><div class="p">
    

    <h4>Declaration</h4>    
    <code class="language-swift">func +(lhs: Self, rhs: Self.Stride) -&gt; Self</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/Strideable/"><code>Strideable</code></a>    
</div></div>
</div>
<div class="declaration inherited" id="func-pls_-self-rhs_-self-stride">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-pls_-self-rhs_-self-stride">func +(<wbr>_:<wbr> Self, rhs: Self.Stride)</a>
        
<div class="comment collapse" id="comment-func-pls_-self-rhs_-self-stride"><div class="p">
    

    <h4>Declaration</h4>    
    <code class="language-swift">func +(lhs: Self, rhs: Self.Stride) -&gt; Self</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/Strideable/"><code>Strideable</code></a>    
</div></div>
</div>
<div class="declaration inherited" id="func-pls_-self-rhs_-self-stride">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-pls_-self-rhs_-self-stride">func +(<wbr>_:<wbr> Self, rhs: Self.Stride)</a>
        
<div class="comment collapse" id="comment-func-pls_-self-rhs_-self-stride"><div class="p">
    <p>Adds two values and produces their sum.</p>

<p>The addition operator (<code>+</code>) calculates the sum of its two arguments. For
example:</p>

<pre><code class="language-swift">1 + 2                   // 3
-10 + 15                // 5
-15 + -5                // -20
21.5 + 3.25             // 24.75</code></pre>

<p>You cannot use <code>+</code> with arguments of different types. To add values of
different types, convert one of the values to the other value&#39;s type.</p>

<pre><code class="language-swift">let x: Int8 = 21
let y: Int = 1000000
Int(x) + y              // 1000021</code></pre>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> The first value to add.
  <strong>rhs:</strong> The second value to add.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func +(lhs: Self, rhs: Self.Stride) -&gt; Self</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/FixedWidthInteger/"><code>FixedWidthInteger</code></a>    
</div></div>
</div>
<div class="declaration inherited" id="func-pls_-self-rhs_-self-stride">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-pls_-self-rhs_-self-stride">func +(<wbr>_:<wbr> Self, rhs: Self.Stride)</a>
        
<div class="comment collapse" id="comment-func-pls_-self-rhs_-self-stride"><div class="p">
    <p>Adds two values and produces their sum.</p>

<p>The addition operator (<code>+</code>) calculates the sum of its two arguments. For
example:</p>

<pre><code class="language-swift">1 + 2                   // 3
-10 + 15                // 5
-15 + -5                // -20
21.5 + 3.25             // 24.75</code></pre>

<p>You cannot use <code>+</code> with arguments of different types. To add values of
different types, convert one of the values to the other value&#39;s type.</p>

<pre><code class="language-swift">let x: Int8 = 21
let y: Int = 1000000
Int(x) + y              // 1000021</code></pre>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> The first value to add.
  <strong>rhs:</strong> The second value to add.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func +(lhs: Self, rhs: Self.Stride) -&gt; Self</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/FixedWidthInteger/"><code>FixedWidthInteger</code></a>    
</div></div>
</div>
<div class="declaration inherited" id="func-pls_-self-rhs_-self-stride">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-pls_-self-rhs_-self-stride">func +(<wbr>_:<wbr> Self, rhs: Self.Stride)</a>
        
<div class="comment collapse" id="comment-func-pls_-self-rhs_-self-stride"><div class="p">
    <p>Adds two values and produces their sum.</p>

<p>The addition operator (<code>+</code>) calculates the sum of its two arguments. For
example:</p>

<pre><code class="language-swift">1 + 2                   // 3
-10 + 15                // 5
-15 + -5                // -20
21.5 + 3.25             // 24.75</code></pre>

<p>You cannot use <code>+</code> with arguments of different types. To add values of
different types, convert one of the values to the other value&#39;s type.</p>

<pre><code class="language-swift">let x: Int8 = 21
let y: Int = 1000000
Int(x) + y              // 1000021</code></pre>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> The first value to add.
  <strong>rhs:</strong> The second value to add.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func +(lhs: Self, rhs: Self.Stride) -&gt; Self</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/FixedWidthInteger/"><code>FixedWidthInteger</code></a>    
</div></div>
</div>
<div class="declaration inherited" id="func-pls_-self-rhs_-self-stride">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-pls_-self-rhs_-self-stride">func +(<wbr>_:<wbr> Self, rhs: Self.Stride)</a>
        
<div class="comment collapse" id="comment-func-pls_-self-rhs_-self-stride"><div class="p">
    

    <h4>Declaration</h4>    
    <code class="language-swift">func +(lhs: Self, rhs: Self.Stride) -&gt; Self</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/Strideable/"><code>Strideable</code></a>    
</div></div>
</div>
<div class="declaration inherited" id="func-pls_-self-rhs_-self-stride">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-pls_-self-rhs_-self-stride">func +(<wbr>_:<wbr> Self, rhs: Self.Stride)</a>
        
<div class="comment collapse" id="comment-func-pls_-self-rhs_-self-stride"><div class="p">
    <p>Adds two values and produces their sum.</p>

<p>The addition operator (<code>+</code>) calculates the sum of its two arguments. For
example:</p>

<pre><code class="language-swift">1 + 2                   // 3
-10 + 15                // 5
-15 + -5                // -20
21.5 + 3.25             // 24.75</code></pre>

<p>You cannot use <code>+</code> with arguments of different types. To add values of
different types, convert one of the values to the other value&#39;s type.</p>

<pre><code class="language-swift">let x: Int8 = 21
let y: Int = 1000000
Int(x) + y              // 1000021</code></pre>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> The first value to add.
  <strong>rhs:</strong> The second value to add.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func +(lhs: Self, rhs: Self.Stride) -&gt; Self</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/FixedWidthInteger/"><code>FixedWidthInteger</code></a>    
</div></div>
</div>
<div class="declaration inherited" id="func-pls_-self-rhs_-self-stride">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-pls_-self-rhs_-self-stride">func +(<wbr>_:<wbr> Self, rhs: Self.Stride)</a>
        
<div class="comment collapse" id="comment-func-pls_-self-rhs_-self-stride"><div class="p">
    <p>Adds two values and produces their sum.</p>

<p>The addition operator (<code>+</code>) calculates the sum of its two arguments. For
example:</p>

<pre><code class="language-swift">1 + 2                   // 3
-10 + 15                // 5
-15 + -5                // -20
21.5 + 3.25             // 24.75</code></pre>

<p>You cannot use <code>+</code> with arguments of different types. To add values of
different types, convert one of the values to the other value&#39;s type.</p>

<pre><code class="language-swift">let x: Int8 = 21
let y: Int = 1000000
Int(x) + y              // 1000021</code></pre>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> The first value to add.
  <strong>rhs:</strong> The second value to add.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func +(lhs: Self, rhs: Self.Stride) -&gt; Self</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/FixedWidthInteger/"><code>FixedWidthInteger</code></a>    
</div></div>
</div>
<div class="declaration inherited" id="func-pls_-self-rhs_-self-stride">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-pls_-self-rhs_-self-stride">func +(<wbr>_:<wbr> Self, rhs: Self.Stride)</a>
        
<div class="comment collapse" id="comment-func-pls_-self-rhs_-self-stride"><div class="p">
    

    <h4>Declaration</h4>    
    <code class="language-swift">func +(lhs: Self, rhs: Self.Stride) -&gt; Self</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/Strideable/"><code>Strideable</code></a>    
</div></div>
</div>
<div class="declaration inherited" id="func-pls_-self-rhs_-self-stride">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-pls_-self-rhs_-self-stride">func +(<wbr>_:<wbr> Self, rhs: Self.Stride)</a>
        
<div class="comment collapse" id="comment-func-pls_-self-rhs_-self-stride"><div class="p">
    <p>Adds two values and produces their sum.</p>

<p>The addition operator (<code>+</code>) calculates the sum of its two arguments. For
example:</p>

<pre><code class="language-swift">1 + 2                   // 3
-10 + 15                // 5
-15 + -5                // -20
21.5 + 3.25             // 24.75</code></pre>

<p>You cannot use <code>+</code> with arguments of different types. To add values of
different types, convert one of the values to the other value&#39;s type.</p>

<pre><code class="language-swift">let x: Int8 = 21
let y: Int = 1000000
Int(x) + y              // 1000021</code></pre>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> The first value to add.
  <strong>rhs:</strong> The second value to add.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func +(lhs: Self, rhs: Self.Stride) -&gt; Self</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/FixedWidthInteger/"><code>FixedWidthInteger</code></a>    
</div></div>
</div>
<div class="declaration inherited" id="func-pls_-self-rhs_-self-stride">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-pls_-self-rhs_-self-stride">func +(<wbr>_:<wbr> Self, rhs: Self.Stride)</a>
        
<div class="comment collapse" id="comment-func-pls_-self-rhs_-self-stride"><div class="p">
    

    <h4>Declaration</h4>    
    <code class="language-swift">func +(lhs: Self, rhs: Self.Stride) -&gt; Self</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/Strideable/"><code>Strideable</code></a>    
</div></div>
</div>
<div class="declaration inherited" id="func-pls_-self-stride-rhs_-self">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-pls_-self-stride-rhs_-self">func +(<wbr>_:<wbr> Self.Stride, rhs: Self)</a>
        
<div class="comment collapse" id="comment-func-pls_-self-stride-rhs_-self"><div class="p">
    <p>Adds two values and produces their sum.</p>

<p>The addition operator (<code>+</code>) calculates the sum of its two arguments. For
example:</p>

<pre><code class="language-swift">1 + 2                   // 3
-10 + 15                // 5
-15 + -5                // -20
21.5 + 3.25             // 24.75</code></pre>

<p>You cannot use <code>+</code> with arguments of different types. To add values of
different types, convert one of the values to the other value&#39;s type.</p>

<pre><code class="language-swift">let x: Int8 = 21
let y: Int = 1000000
Int(x) + y              // 1000021</code></pre>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> The first value to add.
  <strong>rhs:</strong> The second value to add.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func +(lhs: Self.Stride, rhs: Self) -&gt; Self</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/FixedWidthInteger/"><code>FixedWidthInteger</code></a>    
</div></div>
</div>
<div class="declaration inherited" id="func-pls_-self-stride-rhs_-self">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-pls_-self-stride-rhs_-self">func +(<wbr>_:<wbr> Self.Stride, rhs: Self)</a>
        
<div class="comment collapse" id="comment-func-pls_-self-stride-rhs_-self"><div class="p">
    <p>Adds two values and produces their sum.</p>

<p>The addition operator (<code>+</code>) calculates the sum of its two arguments. For
example:</p>

<pre><code class="language-swift">1 + 2                   // 3
-10 + 15                // 5
-15 + -5                // -20
21.5 + 3.25             // 24.75</code></pre>

<p>You cannot use <code>+</code> with arguments of different types. To add values of
different types, convert one of the values to the other value&#39;s type.</p>

<pre><code class="language-swift">let x: Int8 = 21
let y: Int = 1000000
Int(x) + y              // 1000021</code></pre>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> The first value to add.
  <strong>rhs:</strong> The second value to add.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func +(lhs: Self.Stride, rhs: Self) -&gt; Self</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/FixedWidthInteger/"><code>FixedWidthInteger</code></a>    
</div></div>
</div>
<div class="declaration inherited" id="func-pls_-self-stride-rhs_-self">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-pls_-self-stride-rhs_-self">func +(<wbr>_:<wbr> Self.Stride, rhs: Self)</a>
        
<div class="comment collapse" id="comment-func-pls_-self-stride-rhs_-self"><div class="p">
    <p>Adds two values and produces their sum.</p>

<p>The addition operator (<code>+</code>) calculates the sum of its two arguments. For
example:</p>

<pre><code class="language-swift">1 + 2                   // 3
-10 + 15                // 5
-15 + -5                // -20
21.5 + 3.25             // 24.75</code></pre>

<p>You cannot use <code>+</code> with arguments of different types. To add values of
different types, convert one of the values to the other value&#39;s type.</p>

<pre><code class="language-swift">let x: Int8 = 21
let y: Int = 1000000
Int(x) + y              // 1000021</code></pre>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> The first value to add.
  <strong>rhs:</strong> The second value to add.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func +(lhs: Self.Stride, rhs: Self) -&gt; Self</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/FixedWidthInteger/"><code>FixedWidthInteger</code></a>    
</div></div>
</div>
<div class="declaration inherited" id="func-pls_-self-stride-rhs_-self">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-pls_-self-stride-rhs_-self">func +(<wbr>_:<wbr> Self.Stride, rhs: Self)</a>
        
<div class="comment collapse" id="comment-func-pls_-self-stride-rhs_-self"><div class="p">
    

    <h4>Declaration</h4>    
    <code class="language-swift">func +(lhs: Self.Stride, rhs: Self) -&gt; Self</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/Strideable/"><code>Strideable</code></a>    
</div></div>
</div>
<div class="declaration inherited" id="func-pls_-self-stride-rhs_-self">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-pls_-self-stride-rhs_-self">func +(<wbr>_:<wbr> Self.Stride, rhs: Self)</a>
        
<div class="comment collapse" id="comment-func-pls_-self-stride-rhs_-self"><div class="p">
    <p>Adds two values and produces their sum.</p>

<p>The addition operator (<code>+</code>) calculates the sum of its two arguments. For
example:</p>

<pre><code class="language-swift">1 + 2                   // 3
-10 + 15                // 5
-15 + -5                // -20
21.5 + 3.25             // 24.75</code></pre>

<p>You cannot use <code>+</code> with arguments of different types. To add values of
different types, convert one of the values to the other value&#39;s type.</p>

<pre><code class="language-swift">let x: Int8 = 21
let y: Int = 1000000
Int(x) + y              // 1000021</code></pre>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> The first value to add.
  <strong>rhs:</strong> The second value to add.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func +(lhs: Self.Stride, rhs: Self) -&gt; Self</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/FixedWidthInteger/"><code>FixedWidthInteger</code></a>    
</div></div>
</div>
<div class="declaration inherited" id="func-pls_-self-stride-rhs_-self">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-pls_-self-stride-rhs_-self">func +(<wbr>_:<wbr> Self.Stride, rhs: Self)</a>
        
<div class="comment collapse" id="comment-func-pls_-self-stride-rhs_-self"><div class="p">
    <p>Adds two values and produces their sum.</p>

<p>The addition operator (<code>+</code>) calculates the sum of its two arguments. For
example:</p>

<pre><code class="language-swift">1 + 2                   // 3
-10 + 15                // 5
-15 + -5                // -20
21.5 + 3.25             // 24.75</code></pre>

<p>You cannot use <code>+</code> with arguments of different types. To add values of
different types, convert one of the values to the other value&#39;s type.</p>

<pre><code class="language-swift">let x: Int8 = 21
let y: Int = 1000000
Int(x) + y              // 1000021</code></pre>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> The first value to add.
  <strong>rhs:</strong> The second value to add.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func +(lhs: Self.Stride, rhs: Self) -&gt; Self</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/FixedWidthInteger/"><code>FixedWidthInteger</code></a>    
</div></div>
</div>
<div class="declaration inherited" id="func-pls_-self-stride-rhs_-self">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-pls_-self-stride-rhs_-self">func +(<wbr>_:<wbr> Self.Stride, rhs: Self)</a>
        
<div class="comment collapse" id="comment-func-pls_-self-stride-rhs_-self"><div class="p">
    

    <h4>Declaration</h4>    
    <code class="language-swift">func +(lhs: Self.Stride, rhs: Self) -&gt; Self</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/Strideable/"><code>Strideable</code></a>    
</div></div>
</div>
<div class="declaration inherited" id="func-pls_-self-stride-rhs_-self">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-pls_-self-stride-rhs_-self">func +(<wbr>_:<wbr> Self.Stride, rhs: Self)</a>
        
<div class="comment collapse" id="comment-func-pls_-self-stride-rhs_-self"><div class="p">
    <p>Adds two values and produces their sum.</p>

<p>The addition operator (<code>+</code>) calculates the sum of its two arguments. For
example:</p>

<pre><code class="language-swift">1 + 2                   // 3
-10 + 15                // 5
-15 + -5                // -20
21.5 + 3.25             // 24.75</code></pre>

<p>You cannot use <code>+</code> with arguments of different types. To add values of
different types, convert one of the values to the other value&#39;s type.</p>

<pre><code class="language-swift">let x: Int8 = 21
let y: Int = 1000000
Int(x) + y              // 1000021</code></pre>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> The first value to add.
  <strong>rhs:</strong> The second value to add.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func +(lhs: Self.Stride, rhs: Self) -&gt; Self</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/FixedWidthInteger/"><code>FixedWidthInteger</code></a>    
</div></div>
</div>
<div class="declaration inherited" id="func-pls_-self-stride-rhs_-self">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-pls_-self-stride-rhs_-self">func +(<wbr>_:<wbr> Self.Stride, rhs: Self)</a>
        
<div class="comment collapse" id="comment-func-pls_-self-stride-rhs_-self"><div class="p">
    <p>Adds two values and produces their sum.</p>

<p>The addition operator (<code>+</code>) calculates the sum of its two arguments. For
example:</p>

<pre><code class="language-swift">1 + 2                   // 3
-10 + 15                // 5
-15 + -5                // -20
21.5 + 3.25             // 24.75</code></pre>

<p>You cannot use <code>+</code> with arguments of different types. To add values of
different types, convert one of the values to the other value&#39;s type.</p>

<pre><code class="language-swift">let x: Int8 = 21
let y: Int = 1000000
Int(x) + y              // 1000021</code></pre>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> The first value to add.
  <strong>rhs:</strong> The second value to add.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func +(lhs: Self.Stride, rhs: Self) -&gt; Self</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/FixedWidthInteger/"><code>FixedWidthInteger</code></a>    
</div></div>
</div>
<div class="declaration inherited" id="func-pls_-self-stride-rhs_-self">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-pls_-self-stride-rhs_-self">func +(<wbr>_:<wbr> Self.Stride, rhs: Self)</a>
        
<div class="comment collapse" id="comment-func-pls_-self-stride-rhs_-self"><div class="p">
    <p>Adds two values and produces their sum, rounded to a
representable value.</p>

<p>The addition operator (<code>+</code>) calculates the sum of its two arguments. For
example:</p>

<pre><code class="language-swift">let x = 1.5
let y = x + 2.25
// y == 3.75</code></pre>

<p>The <code>+</code> operator implements the addition operation defined by the
<a href="http://ieeexplore.ieee.org/servlet/opac?punumber=4610933">IEEE 754 specification</a>.</p>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> The first value to add.
  <strong>rhs:</strong> The second value to add.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func +(lhs: Self.Stride, rhs: Self) -&gt; Self</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/BinaryFloatingPoint/"><code>BinaryFloatingPoint</code></a>,    <a href="../../protocol/Strideable/"><code>Strideable</code></a>    
</div></div>
</div>
<div class="declaration inherited" id="func-pls_-self-stride-rhs_-self">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-pls_-self-stride-rhs_-self">func +(<wbr>_:<wbr> Self.Stride, rhs: Self)</a>
        
<div class="comment collapse" id="comment-func-pls_-self-stride-rhs_-self"><div class="p">
    <p>Adds two values and produces their sum.</p>

<p>The addition operator (<code>+</code>) calculates the sum of its two arguments. For
example:</p>

<pre><code class="language-swift">1 + 2                   // 3
-10 + 15                // 5
-15 + -5                // -20
21.5 + 3.25             // 24.75</code></pre>

<p>You cannot use <code>+</code> with arguments of different types. To add values of
different types, convert one of the values to the other value&#39;s type.</p>

<pre><code class="language-swift">let x: Int8 = 21
let y: Int = 1000000
Int(x) + y              // 1000021</code></pre>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> The first value to add.
  <strong>rhs:</strong> The second value to add.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func +(lhs: Self.Stride, rhs: Self) -&gt; Self</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/FixedWidthInteger/"><code>FixedWidthInteger</code></a>    
</div></div>
</div>
<div class="declaration inherited" id="func-pls_-self-stride-rhs_-self">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-pls_-self-stride-rhs_-self">func +(<wbr>_:<wbr> Self.Stride, rhs: Self)</a>
        
<div class="comment collapse" id="comment-func-pls_-self-stride-rhs_-self"><div class="p">
    <p>Adds two values and produces their sum.</p>

<p>The addition operator (<code>+</code>) calculates the sum of its two arguments. For
example:</p>

<pre><code class="language-swift">1 + 2                   // 3
-10 + 15                // 5
-15 + -5                // -20
21.5 + 3.25             // 24.75</code></pre>

<p>You cannot use <code>+</code> with arguments of different types. To add values of
different types, convert one of the values to the other value&#39;s type.</p>

<pre><code class="language-swift">let x: Int8 = 21
let y: Int = 1000000
Int(x) + y              // 1000021</code></pre>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> The first value to add.
  <strong>rhs:</strong> The second value to add.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func +(lhs: Self.Stride, rhs: Self) -&gt; Self</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/FixedWidthInteger/"><code>FixedWidthInteger</code></a>    
</div></div>
</div>
<div class="declaration inherited" id="func-pls_-self-stride-rhs_-self">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-pls_-self-stride-rhs_-self">func +(<wbr>_:<wbr> Self.Stride, rhs: Self)</a>
        
<div class="comment collapse" id="comment-func-pls_-self-stride-rhs_-self"><div class="p">
    

    <h4>Declaration</h4>    
    <code class="language-swift">func +(lhs: Self.Stride, rhs: Self) -&gt; Self</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/Strideable/"><code>Strideable</code></a>    
</div></div>
</div>
<div class="declaration inherited" id="func-pls_-self-stride-rhs_-self">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-pls_-self-stride-rhs_-self">func +(<wbr>_:<wbr> Self.Stride, rhs: Self)</a>
        
<div class="comment collapse" id="comment-func-pls_-self-stride-rhs_-self"><div class="p">
    <p>Adds two values and produces their sum.</p>

<p>The addition operator (<code>+</code>) calculates the sum of its two arguments. For
example:</p>

<pre><code class="language-swift">1 + 2                   // 3
-10 + 15                // 5
-15 + -5                // -20
21.5 + 3.25             // 24.75</code></pre>

<p>You cannot use <code>+</code> with arguments of different types. To add values of
different types, convert one of the values to the other value&#39;s type.</p>

<pre><code class="language-swift">let x: Int8 = 21
let y: Int = 1000000
Int(x) + y              // 1000021</code></pre>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> The first value to add.
  <strong>rhs:</strong> The second value to add.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func +(lhs: Self.Stride, rhs: Self) -&gt; Self</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/FixedWidthInteger/"><code>FixedWidthInteger</code></a>    
</div></div>
</div>
<div class="declaration inherited" id="func-pls_-self-stride-rhs_-self">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-pls_-self-stride-rhs_-self">func +(<wbr>_:<wbr> Self.Stride, rhs: Self)</a>
        
<div class="comment collapse" id="comment-func-pls_-self-stride-rhs_-self"><div class="p">
    

    <h4>Declaration</h4>    
    <code class="language-swift">func +(lhs: Self.Stride, rhs: Self) -&gt; Self</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/Strideable/"><code>Strideable</code></a>    
</div></div>
</div>
<div class="declaration inherited" id="func-pls_-self-stride-rhs_-self">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-pls_-self-stride-rhs_-self">func +(<wbr>_:<wbr> Self.Stride, rhs: Self)</a>
        
<div class="comment collapse" id="comment-func-pls_-self-stride-rhs_-self"><div class="p">
    

    <h4>Declaration</h4>    
    <code class="language-swift">func +(lhs: Self.Stride, rhs: Self) -&gt; Self</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/Strideable/"><code>Strideable</code></a>    
</div></div>
</div>
<div class="declaration" id="func-pls_-string-rhs_-string">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-pls_-string-rhs_-string">func +(<wbr>_:<wbr> String, rhs: String)</a>
        
<div class="comment collapse" id="comment-func-pls_-string-rhs_-string"><div class="p">
    

    <h4>Declaration</h4>    
    <code class="language-swift">func +(lhs: String, rhs: String) -&gt; String</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-pls_-uint-rhs_-uint">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-pls_-uint-rhs_-uint">func +(<wbr>_:<wbr> UInt, rhs: UInt)</a>
        
<div class="comment collapse" id="comment-func-pls_-uint-rhs_-uint"><div class="p">
    <p>Adds two values and produces their sum.</p>

<p>The addition operator (<code>+</code>) calculates the sum of its two arguments. For
example:</p>

<pre><code class="language-swift">1 + 2                   // 3
-10 + 15                // 5
-15 + -5                // -20
21.5 + 3.25             // 24.75</code></pre>

<p>You cannot use <code>+</code> with arguments of different types. To add values of
different types, convert one of the values to the other value&#39;s type.</p>

<pre><code class="language-swift">let x: Int8 = 21
let y: Int = 1000000
Int(x) + y              // 1000021</code></pre>

<p>The sum of the two arguments must be representable in the arguments&#39;
type. In the following example, the result of <code>21 + 120</code> is greater than
the maximum representable <code>Int8</code> value:</p>

<pre><code class="language-swift">x + 120                 // Overflow error</code></pre>

<p><strong>Note:</strong> Overflow checking is not performed in <code>-Ounchecked</code> builds.</p>

<p>If you want to opt out of overflow checking and ignore any overflow, use
the overflow addition operator (<code>&amp;+</code>).</p>

<pre><code class="language-swift">x &amp;+ 120                // -115</code></pre>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> The first value to add.
  <strong>rhs:</strong> The second value to add.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func +(lhs: UInt, rhs: UInt) -&gt; UInt</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-pls_-uint8-rhs_-uint8">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-pls_-uint8-rhs_-uint8">func +(<wbr>_:<wbr> UInt8, rhs: UInt8)</a>
        
<div class="comment collapse" id="comment-func-pls_-uint8-rhs_-uint8"><div class="p">
    <p>Adds two values and produces their sum.</p>

<p>The addition operator (<code>+</code>) calculates the sum of its two arguments. For
example:</p>

<pre><code class="language-swift">1 + 2                   // 3
-10 + 15                // 5
-15 + -5                // -20
21.5 + 3.25             // 24.75</code></pre>

<p>You cannot use <code>+</code> with arguments of different types. To add values of
different types, convert one of the values to the other value&#39;s type.</p>

<pre><code class="language-swift">let x: Int8 = 21
let y: Int = 1000000
Int(x) + y              // 1000021</code></pre>

<p>The sum of the two arguments must be representable in the arguments&#39;
type. In the following example, the result of <code>21 + 120</code> is greater than
the maximum representable <code>Int8</code> value:</p>

<pre><code class="language-swift">x + 120                 // Overflow error</code></pre>

<p><strong>Note:</strong> Overflow checking is not performed in <code>-Ounchecked</code> builds.</p>

<p>If you want to opt out of overflow checking and ignore any overflow, use
the overflow addition operator (<code>&amp;+</code>).</p>

<pre><code class="language-swift">x &amp;+ 120                // -115</code></pre>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> The first value to add.
  <strong>rhs:</strong> The second value to add.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func +(lhs: UInt8, rhs: UInt8) -&gt; UInt8</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-pls_-uint16-rhs_-uint16">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-pls_-uint16-rhs_-uint16">func +(<wbr>_:<wbr> UInt16, rhs: UInt16)</a>
        
<div class="comment collapse" id="comment-func-pls_-uint16-rhs_-uint16"><div class="p">
    <p>Adds two values and produces their sum.</p>

<p>The addition operator (<code>+</code>) calculates the sum of its two arguments. For
example:</p>

<pre><code class="language-swift">1 + 2                   // 3
-10 + 15                // 5
-15 + -5                // -20
21.5 + 3.25             // 24.75</code></pre>

<p>You cannot use <code>+</code> with arguments of different types. To add values of
different types, convert one of the values to the other value&#39;s type.</p>

<pre><code class="language-swift">let x: Int8 = 21
let y: Int = 1000000
Int(x) + y              // 1000021</code></pre>

<p>The sum of the two arguments must be representable in the arguments&#39;
type. In the following example, the result of <code>21 + 120</code> is greater than
the maximum representable <code>Int8</code> value:</p>

<pre><code class="language-swift">x + 120                 // Overflow error</code></pre>

<p><strong>Note:</strong> Overflow checking is not performed in <code>-Ounchecked</code> builds.</p>

<p>If you want to opt out of overflow checking and ignore any overflow, use
the overflow addition operator (<code>&amp;+</code>).</p>

<pre><code class="language-swift">x &amp;+ 120                // -115</code></pre>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> The first value to add.
  <strong>rhs:</strong> The second value to add.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func +(lhs: UInt16, rhs: UInt16) -&gt; UInt16</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-pls_-uint32-rhs_-uint32">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-pls_-uint32-rhs_-uint32">func +(<wbr>_:<wbr> UInt32, rhs: UInt32)</a>
        
<div class="comment collapse" id="comment-func-pls_-uint32-rhs_-uint32"><div class="p">
    <p>Adds two values and produces their sum.</p>

<p>The addition operator (<code>+</code>) calculates the sum of its two arguments. For
example:</p>

<pre><code class="language-swift">1 + 2                   // 3
-10 + 15                // 5
-15 + -5                // -20
21.5 + 3.25             // 24.75</code></pre>

<p>You cannot use <code>+</code> with arguments of different types. To add values of
different types, convert one of the values to the other value&#39;s type.</p>

<pre><code class="language-swift">let x: Int8 = 21
let y: Int = 1000000
Int(x) + y              // 1000021</code></pre>

<p>The sum of the two arguments must be representable in the arguments&#39;
type. In the following example, the result of <code>21 + 120</code> is greater than
the maximum representable <code>Int8</code> value:</p>

<pre><code class="language-swift">x + 120                 // Overflow error</code></pre>

<p><strong>Note:</strong> Overflow checking is not performed in <code>-Ounchecked</code> builds.</p>

<p>If you want to opt out of overflow checking and ignore any overflow, use
the overflow addition operator (<code>&amp;+</code>).</p>

<pre><code class="language-swift">x &amp;+ 120                // -115</code></pre>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> The first value to add.
  <strong>rhs:</strong> The second value to add.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func +(lhs: UInt32, rhs: UInt32) -&gt; UInt32</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-pls_-uint64-rhs_-uint64">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-pls_-uint64-rhs_-uint64">func +(<wbr>_:<wbr> UInt64, rhs: UInt64)</a>
        
<div class="comment collapse" id="comment-func-pls_-uint64-rhs_-uint64"><div class="p">
    <p>Adds two values and produces their sum.</p>

<p>The addition operator (<code>+</code>) calculates the sum of its two arguments. For
example:</p>

<pre><code class="language-swift">1 + 2                   // 3
-10 + 15                // 5
-15 + -5                // -20
21.5 + 3.25             // 24.75</code></pre>

<p>You cannot use <code>+</code> with arguments of different types. To add values of
different types, convert one of the values to the other value&#39;s type.</p>

<pre><code class="language-swift">let x: Int8 = 21
let y: Int = 1000000
Int(x) + y              // 1000021</code></pre>

<p>The sum of the two arguments must be representable in the arguments&#39;
type. In the following example, the result of <code>21 + 120</code> is greater than
the maximum representable <code>Int8</code> value:</p>

<pre><code class="language-swift">x + 120                 // Overflow error</code></pre>

<p><strong>Note:</strong> Overflow checking is not performed in <code>-Ounchecked</code> builds.</p>

<p>If you want to opt out of overflow checking and ignore any overflow, use
the overflow addition operator (<code>&amp;+</code>).</p>

<pre><code class="language-swift">x &amp;+ 120                // -115</code></pre>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> The first value to add.
  <strong>rhs:</strong> The second value to add.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func +(lhs: UInt64, rhs: UInt64) -&gt; UInt64</code>
    
    
</div></div>
</div>
<div class="declaration inherited" id="func-pls-other_-other-rhs_-self">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-pls-other_-other-rhs_-self">func + &lt;Other&gt;(<wbr>_:<wbr> Other, rhs: Self)</a>
        
<div class="comment collapse" id="comment-func-pls-other_-other-rhs_-self"><div class="p">
    <p>Creates a new collection by concatenating the elements of a sequence and a
collection.</p>

<p>The two arguments must have the same <code>Element</code> type. For example, you can
concatenate the elements of a <code>Range&lt;Int&gt;</code> instance and an integer array.</p>

<pre><code class="language-swift">let numbers = [7, 8, 9, 10]
let moreNumbers = 1...6 + numbers
print(moreNumbers)
// Prints &quot;[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]&quot;</code></pre>

<p>The resulting collection has the type of argument on the right-hand side.
In the example above, <code>moreNumbers</code> has the same type as <code>numbers</code>, which
is <code>[Int]</code>.</p>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> A collection or finite sequence.
  <strong>rhs:</strong> A range-replaceable collection.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func +&lt;Other&gt;(lhs: Other, rhs: Self) -&gt; Self where Other : Sequence, Self.Element == Other.Element</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/RangeReplaceableCollection/"><code>RangeReplaceableCollection</code></a>    
</div></div>
</div>
<div class="declaration inherited" id="func-pls-other_-other-rhs_-self">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-pls-other_-other-rhs_-self">func + &lt;Other&gt;(<wbr>_:<wbr> Other, rhs: Self)</a>
        
<div class="comment collapse" id="comment-func-pls-other_-other-rhs_-self"><div class="p">
    <p>Creates a new collection by concatenating the elements of a sequence and a
collection.</p>

<p>The two arguments must have the same <code>Element</code> type. For example, you can
concatenate the elements of a <code>Range&lt;Int&gt;</code> instance and an integer array.</p>

<pre><code class="language-swift">let numbers = [7, 8, 9, 10]
let moreNumbers = 1...6 + numbers
print(moreNumbers)
// Prints &quot;[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]&quot;</code></pre>

<p>The resulting collection has the type of argument on the right-hand side.
In the example above, <code>moreNumbers</code> has the same type as <code>numbers</code>, which
is <code>[Int]</code>.</p>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> A collection or finite sequence.
  <strong>rhs:</strong> A range-replaceable collection.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func +&lt;Other&gt;(lhs: Other, rhs: Self) -&gt; Self where Other : Sequence, Self.Element == Other.Element</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/RangeReplaceableCollection/"><code>RangeReplaceableCollection</code></a>    
</div></div>
</div>
<div class="declaration inherited" id="func-pls-other_-other-rhs_-self">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-pls-other_-other-rhs_-self">func + &lt;Other&gt;(<wbr>_:<wbr> Other, rhs: Self)</a>
        
<div class="comment collapse" id="comment-func-pls-other_-other-rhs_-self"><div class="p">
    <p>Creates a new collection by concatenating the elements of a sequence and a
collection.</p>

<p>The two arguments must have the same <code>Element</code> type. For example, you can
concatenate the elements of a <code>Range&lt;Int&gt;</code> instance and an integer array.</p>

<pre><code class="language-swift">let numbers = [7, 8, 9, 10]
let moreNumbers = 1...6 + numbers
print(moreNumbers)
// Prints &quot;[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]&quot;</code></pre>

<p>The resulting collection has the type of argument on the right-hand side.
In the example above, <code>moreNumbers</code> has the same type as <code>numbers</code>, which
is <code>[Int]</code>.</p>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> A collection or finite sequence.
  <strong>rhs:</strong> A range-replaceable collection.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func +&lt;Other&gt;(lhs: Other, rhs: Self) -&gt; Self where Other : Sequence, Self.Element == Other.Element</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/RangeReplaceableCollection/"><code>RangeReplaceableCollection</code></a>    
</div></div>
</div>
<div class="declaration inherited" id="func-pls-other_-other-rhs_-self">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-pls-other_-other-rhs_-self">func + &lt;Other&gt;(<wbr>_:<wbr> Other, rhs: Self)</a>
        
<div class="comment collapse" id="comment-func-pls-other_-other-rhs_-self"><div class="p">
    <p>Creates a new collection by concatenating the elements of a sequence and a
collection.</p>

<p>The two arguments must have the same <code>Element</code> type. For example, you can
concatenate the elements of a <code>Range&lt;Int&gt;</code> instance and an integer array.</p>

<pre><code class="language-swift">let numbers = [7, 8, 9, 10]
let moreNumbers = 1...6 + numbers
print(moreNumbers)
// Prints &quot;[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]&quot;</code></pre>

<p>The resulting collection has the type of argument on the right-hand side.
In the example above, <code>moreNumbers</code> has the same type as <code>numbers</code>, which
is <code>[Int]</code>.</p>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> A collection or finite sequence.
  <strong>rhs:</strong> A range-replaceable collection.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func +&lt;Other&gt;(lhs: Other, rhs: Self) -&gt; Self where Other : Sequence, Self.Element == Other.Element</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/RangeReplaceableCollection/"><code>RangeReplaceableCollection</code></a>    
</div></div>
</div>
<div class="declaration inherited" id="func-pls-other_-other-rhs_-self">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-pls-other_-other-rhs_-self">func + &lt;Other&gt;(<wbr>_:<wbr> Other, rhs: Self)</a>
        
<div class="comment collapse" id="comment-func-pls-other_-other-rhs_-self"><div class="p">
    <p>Creates a new collection by concatenating the elements of a sequence and a
collection.</p>

<p>The two arguments must have the same <code>Element</code> type. For example, you can
concatenate the elements of a <code>Range&lt;Int&gt;</code> instance and an integer array.</p>

<pre><code class="language-swift">let numbers = [7, 8, 9, 10]
let moreNumbers = 1...6 + numbers
print(moreNumbers)
// Prints &quot;[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]&quot;</code></pre>

<p>The resulting collection has the type of argument on the right-hand side.
In the example above, <code>moreNumbers</code> has the same type as <code>numbers</code>, which
is <code>[Int]</code>.</p>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> A collection or finite sequence.
  <strong>rhs:</strong> A range-replaceable collection.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func +&lt;Other&gt;(lhs: Other, rhs: Self) -&gt; Self where Other : Sequence, Self.Element == Other.Element</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/RangeReplaceableCollection/"><code>RangeReplaceableCollection</code></a>    
</div></div>
</div>
<div class="declaration inherited" id="func-pls-other_-other-rhs_-self">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-pls-other_-other-rhs_-self">func + &lt;Other&gt;(<wbr>_:<wbr> Other, rhs: Self)</a>
        
<div class="comment collapse" id="comment-func-pls-other_-other-rhs_-self"><div class="p">
    <p>Creates a new collection by concatenating the elements of a sequence and a
collection.</p>

<p>The two arguments must have the same <code>Element</code> type. For example, you can
concatenate the elements of a <code>Range&lt;Int&gt;</code> instance and an integer array.</p>

<pre><code class="language-swift">let numbers = [7, 8, 9, 10]
let moreNumbers = 1...6 + numbers
print(moreNumbers)
// Prints &quot;[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]&quot;</code></pre>

<p>The resulting collection has the type of argument on the right-hand side.
In the example above, <code>moreNumbers</code> has the same type as <code>numbers</code>, which
is <code>[Int]</code>.</p>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> A collection or finite sequence.
  <strong>rhs:</strong> A range-replaceable collection.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func +&lt;Other&gt;(lhs: Other, rhs: Self) -&gt; Self where Other : Sequence, Self.Element == Other.Element</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/RangeReplaceableCollection/"><code>RangeReplaceableCollection</code></a>    
</div></div>
</div>
<div class="declaration inherited" id="func-pls-other_-other-rhs_-self">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-pls-other_-other-rhs_-self">func + &lt;Other&gt;(<wbr>_:<wbr> Other, rhs: Self)</a>
        
<div class="comment collapse" id="comment-func-pls-other_-other-rhs_-self"><div class="p">
    <p>Creates a new collection by concatenating the elements of a sequence and a
collection.</p>

<p>The two arguments must have the same <code>Element</code> type. For example, you can
concatenate the elements of a <code>Range&lt;Int&gt;</code> instance and an integer array.</p>

<pre><code class="language-swift">let numbers = [7, 8, 9, 10]
let moreNumbers = 1...6 + numbers
print(moreNumbers)
// Prints &quot;[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]&quot;</code></pre>

<p>The resulting collection has the type of argument on the right-hand side.
In the example above, <code>moreNumbers</code> has the same type as <code>numbers</code>, which
is <code>[Int]</code>.</p>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> A collection or finite sequence.
  <strong>rhs:</strong> A range-replaceable collection.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func +&lt;Other&gt;(lhs: Other, rhs: Self) -&gt; Self where Other : Sequence, Self.Element == Other.Element</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/RangeReplaceableCollection/"><code>RangeReplaceableCollection</code></a>    
</div></div>
</div>
<div class="declaration inherited" id="func-pls-other_-self-rhs_-other">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-pls-other_-self-rhs_-other">func + &lt;Other&gt;(<wbr>_:<wbr> Self, rhs: Other)</a>
        
<div class="comment collapse" id="comment-func-pls-other_-self-rhs_-other"><div class="p">
    <p>Creates a new collection by concatenating the elements of two collections.</p>

<p>The two arguments must have the same <code>Element</code> type. For example, you can
concatenate the elements of two integer arrays.</p>

<pre><code class="language-swift">let lowerNumbers = [1, 2, 3, 4]
let higherNumbers: ContiguousArray = [5, 6, 7, 8, 9, 10]
let allNumbers = lowerNumbers + higherNumbers
print(allNumbers)
// Prints &quot;[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]&quot;</code></pre>

<p>The resulting collection has the type of the argument on the left-hand
side. In the example above, <code>moreNumbers</code> has the same type as <code>numbers</code>,
which is <code>[Int]</code>.</p>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> A range-replaceable collection.
  <strong>rhs:</strong> Another range-replaceable collection.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func +&lt;Other&gt;(lhs: Self, rhs: Other) -&gt; Self where Other : RangeReplaceableCollection, Self.Element == Other.Element</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/RangeReplaceableCollection/"><code>RangeReplaceableCollection</code></a>    
</div></div>
</div>
<div class="declaration inherited" id="func-pls-other_-self-rhs_-other">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-pls-other_-self-rhs_-other">func + &lt;Other&gt;(<wbr>_:<wbr> Self, rhs: Other)</a>
        
<div class="comment collapse" id="comment-func-pls-other_-self-rhs_-other"><div class="p">
    <p>Creates a new collection by concatenating the elements of two collections.</p>

<p>The two arguments must have the same <code>Element</code> type. For example, you can
concatenate the elements of two integer arrays.</p>

<pre><code class="language-swift">let lowerNumbers = [1, 2, 3, 4]
let higherNumbers: ContiguousArray = [5, 6, 7, 8, 9, 10]
let allNumbers = lowerNumbers + higherNumbers
print(allNumbers)
// Prints &quot;[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]&quot;</code></pre>

<p>The resulting collection has the type of the argument on the left-hand
side. In the example above, <code>moreNumbers</code> has the same type as <code>numbers</code>,
which is <code>[Int]</code>.</p>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> A range-replaceable collection.
  <strong>rhs:</strong> Another range-replaceable collection.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func +&lt;Other&gt;(lhs: Self, rhs: Other) -&gt; Self where Other : RangeReplaceableCollection, Self.Element == Other.Element</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/RangeReplaceableCollection/"><code>RangeReplaceableCollection</code></a>    
</div></div>
</div>
<div class="declaration inherited" id="func-pls-other_-self-rhs_-other">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-pls-other_-self-rhs_-other">func + &lt;Other&gt;(<wbr>_:<wbr> Self, rhs: Other)</a>
        
<div class="comment collapse" id="comment-func-pls-other_-self-rhs_-other"><div class="p">
    <p>Creates a new collection by concatenating the elements of two collections.</p>

<p>The two arguments must have the same <code>Element</code> type. For example, you can
concatenate the elements of two integer arrays.</p>

<pre><code class="language-swift">let lowerNumbers = [1, 2, 3, 4]
let higherNumbers: ContiguousArray = [5, 6, 7, 8, 9, 10]
let allNumbers = lowerNumbers + higherNumbers
print(allNumbers)
// Prints &quot;[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]&quot;</code></pre>

<p>The resulting collection has the type of the argument on the left-hand
side. In the example above, <code>moreNumbers</code> has the same type as <code>numbers</code>,
which is <code>[Int]</code>.</p>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> A range-replaceable collection.
  <strong>rhs:</strong> Another range-replaceable collection.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func +&lt;Other&gt;(lhs: Self, rhs: Other) -&gt; Self where Other : RangeReplaceableCollection, Self.Element == Other.Element</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/RangeReplaceableCollection/"><code>RangeReplaceableCollection</code></a>    
</div></div>
</div>
<div class="declaration inherited" id="func-pls-other_-self-rhs_-other">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-pls-other_-self-rhs_-other">func + &lt;Other&gt;(<wbr>_:<wbr> Self, rhs: Other)</a>
        
<div class="comment collapse" id="comment-func-pls-other_-self-rhs_-other"><div class="p">
    <p>Creates a new collection by concatenating the elements of two collections.</p>

<p>The two arguments must have the same <code>Element</code> type. For example, you can
concatenate the elements of two integer arrays.</p>

<pre><code class="language-swift">let lowerNumbers = [1, 2, 3, 4]
let higherNumbers: ContiguousArray = [5, 6, 7, 8, 9, 10]
let allNumbers = lowerNumbers + higherNumbers
print(allNumbers)
// Prints &quot;[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]&quot;</code></pre>

<p>The resulting collection has the type of the argument on the left-hand
side. In the example above, <code>moreNumbers</code> has the same type as <code>numbers</code>,
which is <code>[Int]</code>.</p>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> A range-replaceable collection.
  <strong>rhs:</strong> Another range-replaceable collection.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func +&lt;Other&gt;(lhs: Self, rhs: Other) -&gt; Self where Other : RangeReplaceableCollection, Self.Element == Other.Element</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/RangeReplaceableCollection/"><code>RangeReplaceableCollection</code></a>    
</div></div>
</div>
<div class="declaration inherited" id="func-pls-other_-self-rhs_-other">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-pls-other_-self-rhs_-other">func + &lt;Other&gt;(<wbr>_:<wbr> Self, rhs: Other)</a>
        
<div class="comment collapse" id="comment-func-pls-other_-self-rhs_-other"><div class="p">
    <p>Creates a new collection by concatenating the elements of a collection and
a sequence.</p>

<p>The two arguments must have the same <code>Element</code> type. For example, you can
concatenate the elements of an integer array and a <code>Range&lt;Int&gt;</code> instance.</p>

<pre><code class="language-swift">let numbers = [1, 2, 3, 4]
let moreNumbers = numbers + 5...10
print(moreNumbers)
// Prints &quot;[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]&quot;</code></pre>

<p>The resulting collection has the type of the argument on the left-hand
side. In the example above, <code>moreNumbers</code> has the same type as <code>numbers</code>,
which is <code>[Int]</code>.</p>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> A range-replaceable collection.
  <strong>rhs:</strong> A collection or finite sequence.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func +&lt;Other&gt;(lhs: Self, rhs: Other) -&gt; Self where Other : Sequence, Self.Element == Other.Element</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/RangeReplaceableCollection/"><code>RangeReplaceableCollection</code></a>    
</div></div>
</div>
<div class="declaration inherited" id="func-pls-other_-self-rhs_-other">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-pls-other_-self-rhs_-other">func + &lt;Other&gt;(<wbr>_:<wbr> Self, rhs: Other)</a>
        
<div class="comment collapse" id="comment-func-pls-other_-self-rhs_-other"><div class="p">
    <p>Creates a new collection by concatenating the elements of a collection and
a sequence.</p>

<p>The two arguments must have the same <code>Element</code> type. For example, you can
concatenate the elements of an integer array and a <code>Range&lt;Int&gt;</code> instance.</p>

<pre><code class="language-swift">let numbers = [1, 2, 3, 4]
let moreNumbers = numbers + 5...10
print(moreNumbers)
// Prints &quot;[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]&quot;</code></pre>

<p>The resulting collection has the type of the argument on the left-hand
side. In the example above, <code>moreNumbers</code> has the same type as <code>numbers</code>,
which is <code>[Int]</code>.</p>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> A range-replaceable collection.
  <strong>rhs:</strong> A collection or finite sequence.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func +&lt;Other&gt;(lhs: Self, rhs: Other) -&gt; Self where Other : Sequence, Self.Element == Other.Element</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/RangeReplaceableCollection/"><code>RangeReplaceableCollection</code></a>    
</div></div>
</div>
<div class="declaration inherited" id="func-pls-other_-self-rhs_-other">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-pls-other_-self-rhs_-other">func + &lt;Other&gt;(<wbr>_:<wbr> Self, rhs: Other)</a>
        
<div class="comment collapse" id="comment-func-pls-other_-self-rhs_-other"><div class="p">
    <p>Creates a new collection by concatenating the elements of a collection and
a sequence.</p>

<p>The two arguments must have the same <code>Element</code> type. For example, you can
concatenate the elements of an integer array and a <code>Range&lt;Int&gt;</code> instance.</p>

<pre><code class="language-swift">let numbers = [1, 2, 3, 4]
let moreNumbers = numbers + 5...10
print(moreNumbers)
// Prints &quot;[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]&quot;</code></pre>

<p>The resulting collection has the type of the argument on the left-hand
side. In the example above, <code>moreNumbers</code> has the same type as <code>numbers</code>,
which is <code>[Int]</code>.</p>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> A range-replaceable collection.
  <strong>rhs:</strong> A collection or finite sequence.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func +&lt;Other&gt;(lhs: Self, rhs: Other) -&gt; Self where Other : Sequence, Self.Element == Other.Element</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/RangeReplaceableCollection/"><code>RangeReplaceableCollection</code></a>    
</div></div>
</div>
